/*
 * FreeRTOS V202212.00
 * Copyright (C) 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of
 * this software and associated documentation files (the "Software"), to deal in
 * the Software without restriction, including without limitation the rights to
 * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
 * the Software, and to permit persons to whom the Software is furnished to do so,
 * subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
 * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 * https://www.FreeRTOS.org
 * https://github.com/FreeRTOS
 *
 */

/******************************************************************************
*
* See the following URL for information on the commands defined in this file:
* http://localhost/FreeRTOS-Plus/FreeRTOS_Plus_UDP/Embedded_Ethernet_Examples/Ethernet_Related_CLI_Commands.shtml
*
******************************************************************************/


/* FreeRTOS includes. */
#include "FreeRTOS.h"
#include "task.h"

/* Standard includes. */
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>

/* FreeRTOS+CLI includes. */
#include "FreeRTOS_CLI.h"

/* FreeRTOS+UDP includes, just to make the stats available to the CLI
 * commands. */
#include "FreeRTOS_UDP_IP.h"
#include "FreeRTOS_Sockets.h"

#ifndef  configINCLUDE_TRACE_RELATED_CLI_COMMANDS
    #define configINCLUDE_TRACE_RELATED_CLI_COMMANDS    0
#endif


/*
 * Implements the run-time-stats command.
 */
static portBASE_TYPE prvTaskStatsCommand( int8_t * pcWriteBuffer,
                                          size_t xWriteBufferLen,
                                          const int8_t * pcCommandString );

/*
 * Implements the task-stats command.
 */
static portBASE_TYPE prvRunTimeStatsCommand( int8_t * pcWriteBuffer,
                                             size_t xWriteBufferLen,
                                             const int8_t * pcCommandString );

/*
 * Implements the echo-three-parameters command.
 */
static portBASE_TYPE prvThreeParameterEchoCommand( int8_t * pcWriteBuffer,
                                                   size_t xWriteBufferLen,
                                                   const int8_t * pcCommandString );

/*
 * Implements the echo-parameters command.
 */
static portBASE_TYPE prvParameterEchoCommand( int8_t * pcWriteBuffer,
                                              size_t xWriteBufferLen,
                                              const int8_t * pcCommandString );

/*
 * Defines a command that prints out IP address information.
 */
static portBASE_TYPE prvDisplayIPConfig( int8_t * pcWriteBuffer,
                                         size_t xWriteBufferLen,
                                         const int8_t * pcCommandString );

/*
 * Defines a command that prints out the gathered demo debug stats.
 */
static portBASE_TYPE prvDisplayIPDebugStats( int8_t * pcWriteBuffer,
                                             size_t xWriteBufferLen,
                                             const int8_t * pcCommandString );

/*
 * Defines a command that sends an ICMP ping request to an IP address.
 */
static portBASE_TYPE prvPingCommand( int8_t * pcWriteBuffer,
                                     size_t xWriteBufferLen,
                                     const int8_t * pcCommandString );

/*
 * Implements the "trace start" and "trace stop" commands;
 */
#if configINCLUDE_TRACE_RELATED_CLI_COMMANDS == 1
    static portBASE_TYPE prvStartStopTraceCommand( int8_t * pcWriteBuffer,
                                                   size_t xWriteBufferLen,
                                                   const int8_t * pcCommandString );
#endif

/* Structure that defines the "ip-config" command line command. */
static const CLI_Command_Definition_t xIPConfig =
{
    ( const int8_t * const ) "ip-config",
    ( const int8_t * const ) "ip-config:\r\n Displays IP address configuration\r\n\r\n",
    prvDisplayIPConfig,
    0
};

#if configINCLUDE_DEMO_DEBUG_STATS != 0
    /* Structure that defines the "ip-debug-stats" command line command. */
    static const CLI_Command_Definition_t xIPDebugStats =
    {
        ( const int8_t * const ) "ip-debug-stats", /* The command string to type. */
        ( const int8_t * const ) "ip-debug-stats:\r\n Shows some IP stack stats useful for debug - an example only.\r\n\r\n",
        prvDisplayIPDebugStats,                    /* The function to run. */
        0                                          /* No parameters are expected. */
    };
#endif /* configINCLUDE_DEMO_DEBUG_STATS */

/* Structure that defines the "run-time-stats" command line command.   This
 * generates a table that shows how much run time each task has */
static const CLI_Command_Definition_t xRunTimeStats =
{
    ( const int8_t * const ) "run-time-stats", /* The command string to type. */
    ( const int8_t * const ) "run-time-stats:\r\n Displays a table showing how much processing time each FreeRTOS task has used\r\n\r\n",
    prvRunTimeStatsCommand,                    /* The function to run. */
    0                                          /* No parameters are expected. */
};

/* Structure that defines the "task-stats" command line command.  This generates
 * a table that gives information on each task in the system. */
static const CLI_Command_Definition_t xTaskStats =
{
    ( const int8_t * const ) "task-stats", /* The command string to type. */
    ( const int8_t * const ) "task-stats:\r\n Displays a table showing the state of each FreeRTOS task\r\n\r\n",
    prvTaskStatsCommand,                   /* The function to run. */
    0                                      /* No parameters are expected. */
};

/* Structure that defines the "echo_3_parameters" command line command.  This
 * takes exactly three parameters that the command simply echos back one at a
 * time. */
static const CLI_Command_Definition_t xThreeParameterEcho =
{
    ( const int8_t * const ) "echo-3-parameters",
    ( const int8_t * const ) "echo-3-parameters <param1> <param2> <param3>:\r\n Expects three parameters, echos each in turn\r\n\r\n",
    prvThreeParameterEchoCommand, /* The function to run. */
    3                             /* Three parameters are expected, which can take any value. */
};

/* Structure that defines the "echo_parameters" command line command.  This
 * takes a variable number of parameters that the command simply echos back one at
 * a time. */
static const CLI_Command_Definition_t xParameterEcho =
{
    ( const int8_t * const ) "echo-parameters",
    ( const int8_t * const ) "echo-parameters <...>:\r\n Take variable number of parameters, echos each in turn\r\n\r\n",
    prvParameterEchoCommand, /* The function to run. */
    -1                       /* The user can enter any number of commands. */
};

#if ipconfigSUPPORT_OUTGOING_PINGS == 1

/* Structure that defines the "ping" command line command.  This takes an IP
 * address or host name and (optionally) the number of bytes to ping as
 * parameters. */
    static const CLI_Command_Definition_t xPing =
    {
        ( const int8_t * const ) "ping",
        ( const int8_t * const ) "ping <ipaddress> <optional:bytes to send>:\r\n for example, ping 192.168.0.3 8, or ping www.example.com\r\n\r\n",
        prvPingCommand, /* The function to run. */
        -1              /* Ping can take either one or two parameter, so the number of parameters has to be determined by the ping command implementation. */
    };

#endif /* ipconfigSUPPORT_OUTGOING_PINGS */

#if configINCLUDE_TRACE_RELATED_CLI_COMMANDS == 1

/* Structure that defines the "trace" command line command.  This takes a single
 * parameter, which can be either "start" or "stop". */
    static const CLI_Command_Definition_t xStartStopTrace =
    {
        ( const int8_t * const ) "trace",
        ( const int8_t * const ) "trace [start | stop]:\r\n Starts or stops a trace recording for viewing in FreeRTOS+Trace\r\n\r\n",
        prvStartStopTraceCommand, /* The function to run. */
        1                         /* One parameter is expected.  Valid values are "start" and "stop". */
    };
#endif /* configINCLUDE_TRACE_RELATED_CLI_COMMANDS */

/*-----------------------------------------------------------*/

void vRegisterCLICommands( void )
{
    /* Register all the command line commands defined immediately above. */
    FreeRTOS_CLIRegisterCommand( &xTaskStats );
    FreeRTOS_CLIRegisterCommand( &xRunTimeStats );
    FreeRTOS_CLIRegisterCommand( &xThreeParameterEcho );
    FreeRTOS_CLIRegisterCommand( &xParameterEcho );
    FreeRTOS_CLIRegisterCommand( &xIPConfig );

    #if ipconfigSUPPORT_OUTGOING_PINGS == 1
    {
        FreeRTOS_CLIRegisterCommand( &xPing );
    }
    #endif /* ipconfigSUPPORT_OUTGOING_PINGS */

    #if configINCLUDE_TRACE_RELATED_CLI_COMMANDS == 1
        FreeRTOS_CLIRegisterCommand( &xStartStopTrace );
    #endif
}
/*-----------------------------------------------------------*/

static portBASE_TYPE prvTaskStatsCommand( int8_t * pcWriteBuffer,
                                          size_t xWriteBufferLen,
                                          const int8_t * pcCommandString )
{
    const int8_t * const pcHeader = ( int8_t * ) "Task          State  Priority  Stack	#\r\n************************************************\r\n";

    /* Remove compile time warnings about unused parameters, and check the
     * write buffer is not NULL.  NOTE - for simplicity, this example assumes the
     * write buffer length is adequate, so does not check for buffer overflows. */
    ( void ) pcCommandString;
    ( void ) xWriteBufferLen;
    configASSERT( pcWriteBuffer );

    /* Generate a table of task stats. */
    strcpy( ( char * ) pcWriteBuffer, ( char * ) pcHeader );
    vTaskList( pcWriteBuffer + strlen( ( char * ) pcHeader ) );

    /* There is no more data to return after this single string, so return
     * pdFALSE. */
    return pdFALSE;
}
/*-----------------------------------------------------------*/

static portBASE_TYPE prvRunTimeStatsCommand( int8_t * pcWriteBuffer,
                                             size_t xWriteBufferLen,
                                             const int8_t * pcCommandString )
{
    const int8_t * const pcHeader = ( int8_t * ) "Task            Abs Time      % Time\r\n****************************************\r\n";

    /* Remove compile time warnings about unused parameters, and check the
     * write buffer is not NULL.  NOTE - for simplicity, this example assumes the
     * write buffer length is adequate, so does not check for buffer overflows. */
    ( void ) pcCommandString;
    ( void ) xWriteBufferLen;
    configASSERT( pcWriteBuffer );

    /* Generate a table of task stats. */
    strcpy( ( char * ) pcWriteBuffer, ( char * ) pcHeader );

    #if ( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( configUSE_STATS_FORMATTING_FUNCTIONS > 0 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )
        vTaskGetRunTimeStats( pcWriteBuffer + strlen( ( char * ) pcHeader ) );
    #endif

    /* There is no more data to return after this single string, so return
     * pdFALSE. */
    return pdFALSE;
}
/*-----------------------------------------------------------*/

static portBASE_TYPE prvThreeParameterEchoCommand( int8_t * pcWriteBuffer,
                                                   size_t xWriteBufferLen,
                                                   const int8_t * pcCommandString )
{
    int8_t * pcParameter;
    portBASE_TYPE xParameterStringLength, xReturn;
    static portBASE_TYPE lParameterNumber = 0;

    /* Remove compile time warnings about unused parameters, and check the
     * write buffer is not NULL.  NOTE - for simplicity, this example assumes the
     * write buffer length is adequate, so does not check for buffer overflows. */
    ( void ) pcCommandString;
    ( void ) xWriteBufferLen;
    configASSERT( pcWriteBuffer );

    if( lParameterNumber == 0 )
    {
        /* The first time the function is called after the command has been
         * entered just a header string is returned. */
        sprintf( ( char * ) pcWriteBuffer, "The three parameters were:\r\n" );

        /* Next time the function is called the first parameter will be echoed
         * back. */
        lParameterNumber = 1L;

        /* There is more data to be returned as no parameters have been echoed
         * back yet. */
        xReturn = pdPASS;
    }
    else
    {
        /* Obtain the parameter string. */
        pcParameter = ( int8_t * ) FreeRTOS_CLIGetParameter
                      (
            pcCommandString,        /* The command string itself. */
            lParameterNumber,       /* Return the next parameter. */
            &xParameterStringLength /* Store the parameter string length. */
                      );

        /* Sanity check something was returned. */
        configASSERT( pcParameter );

        /* Return the parameter string. */
        memset( pcWriteBuffer, 0x00, xWriteBufferLen );
        sprintf( ( char * ) pcWriteBuffer, "%d: ", ( int ) lParameterNumber );
        strncat( ( char * ) pcWriteBuffer, ( const char * ) pcParameter, xParameterStringLength );
        strncat( ( char * ) pcWriteBuffer, "\r\n", strlen( "\r\n" ) );

        /* If this is the last of the three parameters then there are no more
         * strings to return after this one. */
        if( lParameterNumber == 3L )
        {
            /* If this is the last of the three parameters then there are no more
             * strings to return after this one. */
            xReturn = pdFALSE;
            lParameterNumber = 0L;
        }
        else
        {
            /* There are more parameters to return after this one. */
            xReturn = pdTRUE;
            lParameterNumber++;
        }
    }

    return xReturn;
}
/*-----------------------------------------------------------*/

static portBASE_TYPE prvParameterEchoCommand( int8_t * pcWriteBuffer,
                                              size_t xWriteBufferLen,
                                              const int8_t * pcCommandString )
{
    int8_t * pcParameter;
    portBASE_TYPE xParameterStringLength, xReturn;
    static portBASE_TYPE lParameterNumber = 0;

    /* Remove compile time warnings about unused parameters, and check the
     * write buffer is not NULL.  NOTE - for simplicity, this example assumes the
     * write buffer length is adequate, so does not check for buffer overflows. */
    ( void ) pcCommandString;
    ( void ) xWriteBufferLen;
    configASSERT( pcWriteBuffer );

    if( lParameterNumber == 0 )
    {
        /* The first time the function is called after the command has been
         * entered just a header string is returned. */
        sprintf( ( char * ) pcWriteBuffer, "The parameters were:\r\n" );

        /* Next time the function is called the first parameter will be echoed
         * back. */
        lParameterNumber = 1L;

        /* There is more data to be returned as no parameters have been echoed
         * back yet. */
        xReturn = pdPASS;
    }
    else
    {
        /* Obtain the parameter string. */
        pcParameter = ( int8_t * ) FreeRTOS_CLIGetParameter
                      (
            pcCommandString,        /* The command string itself. */
            lParameterNumber,       /* Return the next parameter. */
            &xParameterStringLength /* Store the parameter string length. */
                      );

        if( pcParameter != NULL )
        {
            /* Return the parameter string. */
            memset( pcWriteBuffer, 0x00, xWriteBufferLen );
            sprintf( ( char * ) pcWriteBuffer, "%d: ", ( int ) lParameterNumber );
            strncat( ( char * ) pcWriteBuffer, ( const char * ) pcParameter, xParameterStringLength );
            strncat( ( char * ) pcWriteBuffer, "\r\n", strlen( "\r\n" ) );

            /* There might be more parameters to return after this one. */
            xReturn = pdTRUE;
            lParameterNumber++;
        }
        else
        {
            /* No more parameters were found.  Make sure the write buffer does
             * not contain a valid string. */
            pcWriteBuffer[ 0 ] = 0x00;

            /* No more data to return. */
            xReturn = pdFALSE;

            /* Start over the next time this command is executed. */
            lParameterNumber = 0;
        }
    }

    return xReturn;
}
/*-----------------------------------------------------------*/

#if ipconfigSUPPORT_OUTGOING_PINGS == 1

    static portBASE_TYPE prvPingCommand( int8_t * pcWriteBuffer,
                                         size_t xWriteBufferLen,
                                         const int8_t * pcCommandString )
    {
        int8_t * pcParameter;
        portBASE_TYPE lParameterStringLength, xReturn;
        uint32_t ulIPAddress, ulBytesToPing;
        const uint32_t ulDefaultBytesToPing = 8UL;
        int8_t cBuffer[ 16 ];

        /* Remove compile time warnings about unused parameters, and check the
         * write buffer is not NULL.  NOTE - for simplicity, this example assumes the
         * write buffer length is adequate, so does not check for buffer overflows. */
        ( void ) pcCommandString;
        ( void ) xWriteBufferLen;
        configASSERT( pcWriteBuffer );

        /* Start with an empty string. */
        pcWriteBuffer[ 0 ] = 0x00;

        /* Obtain the number of bytes to ping. */
        pcParameter = ( int8_t * ) FreeRTOS_CLIGetParameter
                      (
            pcCommandString,        /* The command string itself. */
            2,                      /* Return the second parameter. */
            &lParameterStringLength /* Store the parameter string length. */
                      );

        if( pcParameter == NULL )
        {
            /* The number of bytes was not specified, so default it. */
            ulBytesToPing = ulDefaultBytesToPing;
        }
        else
        {
            ulBytesToPing = atol( ( const char * ) pcParameter );
        }

        /* Obtain the IP address string. */
        pcParameter = ( int8_t * ) FreeRTOS_CLIGetParameter
                      (
            pcCommandString,        /* The command string itself. */
            1,                      /* Return the first parameter. */
            &lParameterStringLength /* Store the parameter string length. */
                      );

        /* Sanity check something was returned. */
        configASSERT( pcParameter );

        /* Attempt to obtain the IP address.   If the first character is not a
         * digit, assume the host name has been passed in. */
        if( ( *pcParameter >= '0' ) && ( *pcParameter <= '9' ) )
        {
            ulIPAddress = FreeRTOS_inet_addr( ( const uint8_t * ) pcParameter );
        }
        else
        {
            /* Terminate the host name. */
            pcParameter[ lParameterStringLength ] = 0x00;

            /* Attempt to resolve host. */
            ulIPAddress = FreeRTOS_gethostbyname( ( uint8_t * ) pcParameter );
        }

        /* Convert IP address, which may have come from a DNS lookup, to string. */
        FreeRTOS_inet_ntoa( ulIPAddress, ( char * ) cBuffer );

        if( ulIPAddress != 0 )
        {
            xReturn = FreeRTOS_SendPingRequest( ulIPAddress, ( uint16_t ) ulBytesToPing, portMAX_DELAY );
        }
        else
        {
            xReturn = pdFALSE;
        }

        if( xReturn == pdFALSE )
        {
            sprintf( ( char * ) pcWriteBuffer, "%s", "Could not send ping request\r\n" );
        }
        else
        {
            sprintf( ( char * ) pcWriteBuffer, "Ping sent to %s with identifier %d\r\n", cBuffer, xReturn );
        }

        return pdFALSE;
    }
    /*-----------------------------------------------------------*/

#endif /* ipconfigSUPPORT_OUTGOING_PINGS */

#if configINCLUDE_DEMO_DEBUG_STATS != 0

    static portBASE_TYPE prvDisplayIPDebugStats( int8_t * pcWriteBuffer,
                                                 size_t xWriteBufferLen,
                                                 const int8_t * pcCommandString )
    {
        static portBASE_TYPE xIndex = -1;
        extern xExampleDebugStatEntry_t xIPTraceValues[];
        portBASE_TYPE xReturn;

        /* Remove compile time warnings about unused parameters, and check the
         * write buffer is not NULL.  NOTE - for simplicity, this example assumes the
         * write buffer length is adequate, so does not check for buffer overflows. */
        ( void ) pcCommandString;
        ( void ) xWriteBufferLen;
        configASSERT( pcWriteBuffer );

        xIndex++;

        if( xIndex < xExampleDebugStatEntries() )
        {
            sprintf( ( char * ) pcWriteBuffer, "%s %d\r\n", ( char * ) xIPTraceValues[ xIndex ].pucDescription, ( int ) xIPTraceValues[ xIndex ].ulData );
            xReturn = pdPASS;
        }
        else
        {
            /* Reset the index for the next time it is called. */
            xIndex = -1;

            /* Ensure nothing remains in the write buffer. */
            pcWriteBuffer[ 0 ] = 0x00;
            xReturn = pdFALSE;
        }

        return xReturn;
    }
    /*-----------------------------------------------------------*/

#endif /* configINCLUDE_DEMO_DEBUG_STATS */

static portBASE_TYPE prvDisplayIPConfig( int8_t * pcWriteBuffer,
                                         size_t xWriteBufferLen,
                                         const int8_t * pcCommandString )
{
    static portBASE_TYPE xIndex = 0;
    portBASE_TYPE xReturn;
    uint32_t ulAddress;

    /* Remove compile time warnings about unused parameters, and check the
     * write buffer is not NULL.  NOTE - for simplicity, this example assumes the
     * write buffer length is adequate, so does not check for buffer overflows. */
    ( void ) pcCommandString;
    ( void ) xWriteBufferLen;
    configASSERT( pcWriteBuffer );

    switch( xIndex )
    {
        case 0:
            #if defined( ipconfigIPv4_BACKWARD_COMPATIBLE ) && ( ipconfigIPv4_BACKWARD_COMPATIBLE == 0 )
                FreeRTOS_GetEndPointConfiguration( &ulAddress, NULL, NULL, NULL, pxNetworkEndPoints );
            #else
                FreeRTOS_GetAddressConfiguration( &ulAddress, NULL, NULL, NULL );
            #endif /* defined( ipconfigIPv4_BACKWARD_COMPATIBLE ) && ( ipconfigIPv4_BACKWARD_COMPATIBLE == 0 ) */
            sprintf( ( char * ) pcWriteBuffer, "\r\nIP address " );
            xReturn = pdTRUE;
            xIndex++;
            break;

        case 1:
            #if defined( ipconfigIPv4_BACKWARD_COMPATIBLE ) && ( ipconfigIPv4_BACKWARD_COMPATIBLE == 0 )
                FreeRTOS_GetEndPointConfiguration( NULL, &ulAddress, NULL, NULL, pxNetworkEndPoints );
            #else
                FreeRTOS_GetAddressConfiguration( NULL, &ulAddress, NULL, NULL );
            #endif /* defined( ipconfigIPv4_BACKWARD_COMPATIBLE ) && ( ipconfigIPv4_BACKWARD_COMPATIBLE == 0 ) */
            sprintf( ( char * ) pcWriteBuffer, "\r\nNet mask " );
            xReturn = pdTRUE;
            xIndex++;
            break;

        case 2:
            #if defined( ipconfigIPv4_BACKWARD_COMPATIBLE ) && ( ipconfigIPv4_BACKWARD_COMPATIBLE == 0 )
                FreeRTOS_GetEndPointConfiguration( NULL, NULL, &ulAddress, NULL, pxNetworkEndPoints );
            #else
                FreeRTOS_GetAddressConfiguration( NULL, NULL, &ulAddress, NULL );
            #endif /* defined( ipconfigIPv4_BACKWARD_COMPATIBLE ) && ( ipconfigIPv4_BACKWARD_COMPATIBLE == 0 ) */
            sprintf( ( char * ) pcWriteBuffer, "\r\nGateway address " );
            xReturn = pdTRUE;
            xIndex++;
            break;

        case 3:
            #if defined( ipconfigIPv4_BACKWARD_COMPATIBLE ) && ( ipconfigIPv4_BACKWARD_COMPATIBLE == 0 )
                FreeRTOS_GetEndPointConfiguration( NULL, NULL, NULL, &ulAddress, pxNetworkEndPoints );
            #else
                FreeRTOS_GetAddressConfiguration( NULL, NULL, NULL, &ulAddress );
            #endif /* defined( ipconfigIPv4_BACKWARD_COMPATIBLE ) && ( ipconfigIPv4_BACKWARD_COMPATIBLE == 0 ) */
            sprintf( ( char * ) pcWriteBuffer, "\r\nDNS server address " );
            xReturn = pdTRUE;
            xIndex++;
            break;

        default:
            ulAddress = 0;
            sprintf( ( char * ) pcWriteBuffer, "\r\n\r\n" );
            xReturn = pdFALSE;
            xIndex = 0;
            break;
    }

    if( ulAddress != 0 )
    {
        FreeRTOS_inet_ntoa( ulAddress, ( ( char * ) &( pcWriteBuffer[ strlen( ( char * ) pcWriteBuffer ) ] ) ) );
    }

    return xReturn;
}
/*-----------------------------------------------------------*/

#if configINCLUDE_TRACE_RELATED_CLI_COMMANDS == 1

    static portBASE_TYPE prvStartStopTraceCommand( int8_t * pcWriteBuffer,
                                                   size_t xWriteBufferLen,
                                                   const int8_t * pcCommandString )
    {
        int8_t * pcParameter;
        portBASE_TYPE lParameterStringLength;

        /* Remove compile time warnings about unused parameters, and check the
         * write buffer is not NULL.  NOTE - for simplicity, this example assumes the
         * write buffer length is adequate, so does not check for buffer overflows. */
        ( void ) pcCommandString;
        ( void ) xWriteBufferLen;
        configASSERT( pcWriteBuffer );

        /* Obtain the parameter string. */
        pcParameter = ( int8_t * ) FreeRTOS_CLIGetParameter
                      (
            pcCommandString,        /* The command string itself. */
            1,                      /* Return the first parameter. */
            &lParameterStringLength /* Store the parameter string length. */
                      );

        /* Sanity check something was returned. */
        configASSERT( pcParameter );

        /* There are only two valid parameter values. */
        if( strncmp( ( const char * ) pcParameter, "start", strlen( "start" ) ) == 0 )
        {
            /* Start or restart the trace. */
            vTraceStop();
            vTraceClear();
            vTraceStart();

            sprintf( ( char * ) pcWriteBuffer, "Trace recording (re)started.\r\n" );
        }
        else if( strncmp( ( const char * ) pcParameter, "stop", strlen( "stop" ) ) == 0 )
        {
            /* End the trace, if one is running. */
            vTraceStop();
            sprintf( ( char * ) pcWriteBuffer, "Stopping trace recording.\r\n" );
        }
        else
        {
            sprintf( ( char * ) pcWriteBuffer, "Valid parameters are 'start' and 'stop'.\r\n" );
        }

        /* There is no more data to return after this single string, so return
         * pdFALSE. */
        return pdFALSE;
    }

#endif /* configINCLUDE_TRACE_RELATED_CLI_COMMANDS */
